package cn.tedu.blog.server.service.impl;


import cn.tedu.blog.server.exception.ServiceException;
import cn.tedu.blog.server.mapper.CategoryMapper;
import cn.tedu.blog.server.pojo.dto.CategoryAddDTO;
import cn.tedu.blog.server.pojo.entity.Category;
import cn.tedu.blog.server.pojo.vo.CategoryDetailVO;
import cn.tedu.blog.server.service.ICategoryService;
import cn.tedu.blog.server.utils.ServiceCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author: 雷茂林
 * @Date:2022/7/17 10:02
 * @Description:
 */
@Slf4j
@Service
public class CategoryServiceImpl implements ICategoryService {
    @Autowired
    private CategoryMapper categoryMapper;

    @Override
    public void addNew(CategoryAddDTO categoryAddDTO) {
        String name=categoryAddDTO.getName();
        int count=categoryMapper.countByName(name);
        if (count>0){
            String message="添加类别失败，类别名称【" + name + "】已经被占用！";
            log.error(message);
            throw new ServiceException(ServiceCode.ERR_INSERT,message);
        }

        Category category=new Category();

        BeanUtils.copyProperties(categoryAddDTO,category);

        log.debug("即将向表中写入数据：{}", category);

        int rows = categoryMapper.insert(category);
        if (rows != 1) {
            String message = "添加类别失败，服务器忙，请稍后再次尝试！【错误码：1】";
            log.error(message);
            throw new ServiceException(ServiceCode.ERR_INSERT,message);
        }
    }

    @Override
    public void deleteById(Long id) {
        log.debug("开始处理删除类别的业务");
        CategoryDetailVO categoryDetailVO=categoryMapper.getById(id);
        if (categoryDetailVO==null){
            String message="删除失败"+id+"不存在";
            log.error(message);
            throw new ServiceException(ServiceCode.ERR_DELETE,message);
        }
        int count=categoryMapper.articleCountById(id);
        if (count>0){
            String message="删除失败，该类别还有文章，不可以删除";
            log.error(message);
            throw new ServiceException(ServiceCode.ERR_DELETE,message);
        }
        int rows=categoryMapper.deleteById(id);
        if (rows!=1){
            String message="删除失败，请联系管理员";
            log.error(message);
            throw new ServiceException(ServiceCode.ERR_DELETE,message);
        }
    }

    @Override
    public void updateById(CategoryAddDTO categoryAddDTO) {
        log.debug("开始处理修改类别的业务");
        Category category=new Category();
        BeanUtils.copyProperties(categoryAddDTO,category);
        categoryMapper.updateById(category);
    }

    @Override
    public List<CategoryDetailVO> list() {
        log.debug("开始处理查询类别的业务");
        return categoryMapper.list();
    }
//    @Autowired
//    private CategoryMapper categoryMapper;
//
//    @Override
//    public List<CategoryDetailVO> select() {
//        return null;
//    }
//
//    @Override
//    public void insert(CategoryAddDTO categoryAddDTO) {
//        log.debug("准备开始处理新增类别的业务，参数：{}", categoryAddDTO);
//        if (categoryAddDTO != null) {
//            if (categoryMapper.isName(0L, categoryAddDTO.getName()) > 0) {
//                throw new ServiceException(ServiceCode.ERR_CONFLICT, "类别名称【" + categoryAddDTO.getName() + "】已被使用！");
//            }
//        }
//
//        Category category = new Category();
//        BeanUtils.copyProperties(categoryAddDTO, category);
//
//        //补全信息
//        category.setCreateTime(LocalDateTime.now());
//        category.setUpdateTime(categoryAddDTO.getCreateTime());
//        log.debug("即将向数据库写入创建的类别，参数：{}", categoryAddDTO);
//
//
//        if (categoryMapper.insert(category) <= 0) {
//            throw new ServiceException(ServiceCode.ERR_INSERT, "新增类别失败，请稍后再试！");
//        }
//    }
//
//
//    @Override
//    public void delete(Long id) {
//        log.debug("准备开始处理删除类别的业务，参数：{}", id);
//        if (categoryMapper.isCategoryById(id) <= 0) {
//            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, "类别不存在");
//        }
//        log.debug("即将移除类别ID为：【{}】的类别", id);
//        if (categoryMapper.delete(id) <= 0) {
//            throw new ServiceException(ServiceCode.ERR_DELETE, "移除类别失败，请稍后再试！");
//        }
//    }
//
//
//    @Override
//    public void update(CategoryAddDTO categoryAddDTO) {
//        log.debug("准备开始处理修改类别的业务，参数：{}", categoryAddDTO);
//        if (categoryAddDTO.getName() != null) {
//            if (categoryMapper.isName(categoryAddDTO.getId(), categoryAddDTO.getName()) > 0) {
//                throw new ServiceException(ServiceCode.ERR_CONFLICT, "类别地址【" + categoryAddDTO.getName() + "】已被使用！");
//            }
//        }
//
//        Category category = new Category();
//        BeanUtils.copyProperties(categoryAddDTO, category);
//
//        category.setUpdateTime(LocalDateTime.now());
//
//        log.debug("即将向数据库写入修改的类别，参数：{}", categoryAddDTO);
//        if (categoryMapper.update(category) <= 0) {
//            throw new ServiceException(ServiceCode.ERR_UPDATE, "修改类别失败，请稍后再试！");
//        }
//    }
//
//
//    @Override
//    public List<CategoryListVO> list(CategoryListVO categoryListVO) {
//        log.debug("准备开始处理条件分页查询类别的业务，参数：{}", categoryListVO);
//
//        LocalDateTime start = categoryListVO.getUpdateTimeStart();
//        LocalDateTime end = categoryListVO.getUpdateTimeEnd();
//        if (start != null && end != null) {
//            categoryListVO.setUpdateTimeStart(start);
//            categoryListVO.setUpdateTimeEnd(end);
//        }
//
//        return categoryMapper.list(categoryListVO);
//    }
//
//
//    @Override
//    public int getCountAll(CategoryListVO categoryListVO) {
//        log.debug("准备开始处理条件查询结果集数量的业务，参数：{}", categoryListVO);
//        return categoryMapper.getCountAll(categoryListVO);
//    }
//
//
//    @Override
//    public CategoryListVO getBackFillById(Long id) {
//        log.debug("准备开始处理数据回填的业务，参数：{}", id);
//        return categoryMapper.getBackFillById(id);
//    }
}
